package com.szholly.utils.util;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Set;
import java.util.Map;
import java.util.List;
import java.util.Queue;
import java.util.HashSet;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.LinkedHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * ���ø��ּ��϶���ĳ��÷����ķ��͹����ࡣ
 * <p>
 * ���Ҫ���һ�� {@code Map<String, String>} �Ķ��󣬿���ͨ������ķ�ʽʵ�֣� {@literal Map<String,
 * String> map = GenericUtils.getMap();}�����ǲ���ֱ����Ϊ����ʹ�ã�����������һ�������� {@literal
 * setInfo(Map<String, String>)}������ֱ��������ã�<s>
 * <code>setInfo(GenericUtils.getMap())</code></s>
 * </p>
 * 
 * @author Fuchun
 * @version $Id: GenericUtils.java 4754 2011-03-26 19:50 fuchun $
 */
public class GenericUtils {

	private GenericUtils() {

	}

	/**
	 * �ø÷��������� {@code new HashMap<K, V>()} ��ʽ����µ� {@code java.util.Map} ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code java.util.HashMap<K, V>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getMap() {
		return new HashMap<K, V>();
	}

	/**
	 * �ø÷��������� {@code new HashMap<K, V>(int)} ��ʽ����µ� {@code java.util.Map}
	 * ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @param initialCapacity
	 *            ��ʼ������
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code java.util.HashMap<K, V>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getMap(int initialCapacity) {
		return new HashMap<K, V>(initialCapacity);
	}

	/**
	 * �ø÷��������� {@code new ConcurrentHashMap<K, V>()} ��ʽ����µ� {@code
	 * java.util.Map} ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code
	 *         java.util.concurrent.ConcurrentHashMap<K, V>} ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getConcurrentMap() {
		return new ConcurrentHashMap<K, V>();
	}

	/**
	 * �ø÷��������� {@code new ConcurrentHashMap<K, V>(int)} ��ʽ����µ� {@code
	 * java.util.Map} ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @param initialCapacity
	 *            ��ʼ������
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code
	 *         java.util.concurrent.ConcurrentHashMap<K, V>} ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getConcurrentMap(int initialCapacity) {
		return new ConcurrentHashMap<K, V>(initialCapacity);
	}

	/**
	 * �ø÷��������� {@code new LinkedHashMap<K, V>()} ��ʽ����µ� {@code java.util.Map}
	 * ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code
	 *         java.util.LinkedHashMap<K, V>} ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getLinkedMap() {
		return new LinkedHashMap<K, V>();
	}

	/**
	 * �ø÷��������� {@code new LinkedHashMap<K, V>(int)} ��ʽ����µ� {@code java.util.Map}
	 * ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @param initialCapacity
	 *            ��ʼ������
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code
	 *         java.util.LinkedHashMap<K, V>} ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getLinkedMap(int initialCapacity) {
		return new LinkedHashMap<K, V>(initialCapacity);
	}

	/**
	 * �ø÷��������� {@code new TreeMap<K, V>()} ��ʽ����µ� {@code java.util.Map} ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @return ���� {@code java.util.Map<K, V>} ���� {@code java.util.TreeMap<K, V>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <K, V> Map<K, V> getTreeMap() {
		return new TreeMap<K, V>();
	}

	/**
	 * �ø÷��������� {@code new ConcurrentHashMap<K, V>()} ��ʽ����µ� {@code
	 * java.util.concurrent.ConcurrentHashMap} ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @return ���� {@code java.util.concurrent.ConcurrentMap<K, V>} ���� {@code
	 *         java.util.concurrent.ConcurrentHashMap<K, V>} ʵ�ֵ���ʵ��
	 */
	public static <K, V> ConcurrentMap<K, V> getConcurrentHashMap() {
		return new ConcurrentHashMap<K, V>();
	}

	/**
	 * �ø÷��������� {@code new ConcurrentHashMap<K, V>(int)} ��ʽ����µ� {@code
	 * java.util.concurrent.ConcurrentHashMap} ��ʵ�����
	 * 
	 * @param <K>
	 *            {@code Map} �еļ����
	 * @param <V>
	 *            {@code Map} �е�ֵ����
	 * @param initialCapacity
	 *            ��ʼ������
	 * @return ���� {@code java.util.concurrent.ConcurrentMap<K, V>} ���� {@code
	 *         java.util.concurrent.ConcurrentHashMap<K, V>} ʵ�ֵ���ʵ��
	 */
	public static <K, V> ConcurrentMap<K, V> getConcurrentHashMap(
			int initialCapacity) {
		return new ConcurrentHashMap<K, V>(initialCapacity);
	}

	/**
	 * �ø÷��������� {@code new ArrayList<T>()} ��ʽ����µ� {@code java.util.List} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code List<T>} �б���Ķ���
	 * @return ���� {@code java.util.List<T>} ���� {@code java.util.ArrayList<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> List<T> getList() {
		return new ArrayList<T>();
	}

	/**
	 * �ø÷��������� {@code new ArrayList<T>(int)} ��ʽ����µ� {@code java.util.List}
	 * ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code List<T>} �б���Ķ���
	 * @param initialCapacity
	 *            �б�ĳ�ʼ������
	 * @return ���� {@code java.util.List<T>} ���� {@code java.util.ArrayList<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> List<T> getList(int initialCapacity) {
		return new ArrayList<T>(initialCapacity);
	}

	/**
	 * �ø÷��������� {@code new ArrayList<T>()} ��ʽ����µ� {@code java.util.List} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code List<T>} �б���Ķ���
	 * @param c
	 *            ���е�Ԫ�ؽ�������µ� {@code list} �е� {@code collection}��
	 * @return ���� {@code java.util.List<T>} ���� {@code java.util.ArrayList<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> List<T> getList(Collection<? extends T> c) {
		// if (ObjectUtils.isNotEmpty(c))
		// return new ArrayList<T>(c);
		return new ArrayList<T>();
	}

	/**
	 * �ø÷��������� {@code new LinkedList<T>()} ��ʽ����µ� {@code java.util.List} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code List<T>} �б���Ķ���
	 * @return ���� {@code java.util.List<T>} ���� {@code java.util.LinkedList<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> List<T> getLinkedList() {
		return new LinkedList<T>();
	}

	/**
	 * �ø÷��������� {@code new HashSet<T>()} ��ʽ����µ� {@code java.util.Set} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code Set<T>} �б���Ķ���
	 * @return ���� {@code java.util.Set<T>} ���� {@code java.util.HashSet<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> Set<T> getHashSet() {
		return new HashSet<T>();
	}

	/**
	 * �ø÷��������� {@code new HashSet<T>(int)} ��ʽ����µ� {@code java.util.Set} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code Set<T>} �б���Ķ���
	 * @param initialCapacity
	 *            �б�ĳ�ʼ������
	 * @return ���� {@code java.util.Set<T>} ���� {@code java.util.HashSet<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> Set<T> getHashSet(int initialCapacity) {
		return new HashSet<T>(initialCapacity);
	}

	/**
	 * �ø÷���������
	 * <code>new HashSet&lt;T&gt;(Collection&lt;? extends T&gt; c)</code> ��ʽ����µ�
	 * {@code java.util.Set} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code Set} �б���Ķ���
	 * @param c
	 *            ���е�Ԫ�ؽ�������µ� {@code set} �е� {@code collection}��
	 * @return ���� {@code java.util.Set<T>} ���� {@code java.util.HashSet<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> Set<T> getHashSet(Collection<? extends T> c) {
		// if (ObjectUtils.isEmpty(c))
		// return new HashSet<T>();
		return new HashSet<T>(c);
	}

	/**
	 * �ø÷��������� {@code new TreeSet<T>()} ��ʽ����µ� {@code java.util.Set} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code Set<T>} �б���Ķ���
	 * @return ���� {@code java.util.Set<T>} ���� {@code java.util.TreeSet<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> Set<T> getTreeSet() {
		return new TreeSet<T>();
	}

	/**
	 * �ø÷���������
	 * <code>new TreeSet&lt;T&gt;(Collection&lt;? extends T&gt; c)</code> ��ʽ����µ�
	 * {@code java.util.Set} ��ʵ�����
	 * 
	 * @param <T>
	 *            {@code Set} �б���Ķ���
	 * @param c
	 *            ���е�Ԫ�ؽ�������µ� {@code set} �е� {@code collection}��
	 * @return ���� {@code java.util.Set<T>} ���� {@code java.util.TreeSet<T>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <T> Set<T> getTreeSet(Collection<? extends T> c) {
		// if (ObjectUtils.isEmpty(c))
		// return new TreeSet<T>();
		return new TreeSet<T>(c);
	}

	/**
	 * �ø÷��������� {@code new LinkedList<E>()} ��ʽ����µ� {@code java.util.Queue} ��ʵ�����
	 * 
	 * @param <E>
	 *            {@code Queue<E>} �б���Ķ���
	 * @return ���� {@code java.util.Queue<E>} ���� {@code java.util.LinkedList<E>}
	 *         ʵ�ֵ���ʵ��
	 */
	public static <E> Queue<E> getQueue() {
		return new LinkedList<E>();
	}

	/**
	 * �ϲ���������ͬԪ�����͵� {@code java.util.Set}��
	 * <ul>
	 * <li>{@code setA == null && setB == null} --&gt; ���� {@link #getHashSet()}��
	 * </li>
	 * <li>{@code setA != null && setB == null} --&gt; ���� {@code setA}��</li>
	 * <li>{@code setA == null && setB != null} --&gt; ���� {@code setB}��</li>
	 * <li>{@code setA != null && setB != null} --&gt; ���� {@code setA} �� {@code
	 * setB} �Ĳ�����</li>
	 * </ul>
	 * 
	 * @param <T>
	 *            {@code Set} �б���Ķ���
	 * @param setA
	 *            ��һ�� {@code Set}��
	 * @param setB
	 *            �ڶ��� {@code Set}��
	 * @return ���� {@code setA} �� {@code setB} �Ĳ�����
	 */
	public static <T> Set<T> unionHashSet(Set<T> setA, Set<T> setB) {
		// boolean isEmptySetA = ObjectUtils.isEmpty(setA);
		// boolean isEmptySetB = ObjectUtils.isEmpty(setB);
		// if (isEmptySetA && isEmptySetB)
		// return getHashSet();
		// if (isEmptySetA && !isEmptySetB)
		// return setB;
		// if (!isEmptySetA && isEmptySetB)
		// return setA;
		Set<T> result = getHashSet(setA);
		result.addAll(setB);
		return result;
	}

	/**
	 * ȡ��������ͬԪ�����͵� {@code java.util.Set} �Ľ��������������ݵ��µ� {@code java.util.Set}��
	 * <ul>
	 * <li>{@code setA == null && setB == null} --&gt; ���� {@code null}��</li>
	 * <li>{@code setA != null && setB == null} --&gt; ���� {@code null}��</li>
	 * <li>{@code setA == null && setB != null} --&gt; ���� {@code null}��</li>
	 * <li>{@code setA != null && setB != null} --&gt; ���� {@code setA} �� {@code
	 * setB} �Ľ�����</li>
	 * </ul>
	 * 
	 * @param <T>
	 *            {@code Set} �б���Ķ���
	 * @param setA
	 *            ��һ�� {@code Set}��
	 * @param setB
	 *            �ڶ��� {@code Set}��
	 * @return ���� {@code setA} �� {@code setB} �Ľ�����
	 */
	public static <T> Set<T> intersectHashSet(Set<T> setA, Set<T> setB) {
		// if (ObjectUtils.isEmpty(setA) || ObjectUtils.isEmpty(setB))
		// return null;
		Set<T> result = getHashSet(setA);
		result.retainAll(setB);
		return result;
	}

	/**
	 * �Ƴ� {@code setA} ����Щ���� {@code setB} �е�Ԫ�ء�<br />
	 * �˷��������޸� {@code setA}��ֻ�Ǹ���һ������Ӧ���������ص���ȫ�µ� {@code Set} ����
	 * <ul>
	 * <li>{@code setA == null} --&gt; ���� {@code null}��</li>
	 * <li>{@code setB == null} --&gt; ���� {@code setA}��</li>
	 * <li>{@code setA != null && setB != null} --&gt; ���� {@code setA} �� {@code
	 * setB} �Ĳ��ԳƲ��</li>
	 * </ul>
	 * 
	 * @param <T>
	 *            {@code Set} �б���Ķ���
	 * @param setA
	 *            ��һ�� {@code Set}��
	 * @param setB
	 *            �ڶ��� {@code Set}��
	 * @return ���� {@code setA} �� {@code setB} �Ĳ��ԳƲ��
	 */
	public static <T> Set<T> differenceHashSet(Set<T> setA, Set<T> setB) {
		// if (ObjectUtils.isEmpty(setA))
		// return null;
		// if (ObjectUtils.isEmpty(setB))
		// return setA;
		Set<T> result = getHashSet(setA);
		result.removeAll(setB);
		return result;
	}

	/**
	 * ȡ��������ͬԪ�����͵� {@code java.util.Set} �Ĳ�����
	 * 
	 * @param <T>
	 *            {@code Set} �б���Ķ���
	 * @param setA
	 *            ��һ�� {@code Set}��
	 * @param setB
	 *            �ڶ��� {@code Set}��
	 * @return ���� {@code setA} �� {@code setB} �Ĳ�����
	 */
	public static <T> Set<T> complementHashSet(Set<T> setA, Set<T> setB) {
		return differenceHashSet(unionHashSet(setA, setB), intersectHashSet(
				setA, setB));
	}
	
	private static final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

	public static final String SESSION_NAME = "session_Object";

	public static final String SESSION_AUTH_NAME = "session_auth";

	/**
	 * count�ֶ���
	 */
	public static final String COUNTFIELDNAME = "COUNTFIELDNAME";

	public static String BASEPATH; // Ӧ��ϵͳ�ĸ�Ŀ¼

	/**
	 * ��ָ���ַ���MD5�����㷨�����ؼ��ܺ��ַ�
	 */
	public final static String MD5(String s) {
		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
				'a', 'b', 'c', 'd', 'e', 'f' };
		try {
			byte[] strTemp = s.getBytes();
			MessageDigest mdTemp = MessageDigest.getInstance("MD5");
			mdTemp.update(strTemp);
			byte[] md = mdTemp.digest();
			int j = md.length;
			char str[] = new char[j * 2];
			int k = 0;
			for (int i = 0; i < j; i++) {
				byte byte0 = md[i];
				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
				str[k++] = hexDigits[byte0 & 0xf];
			}
			return new String(str);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * Сдת��д
	 */
	public static String getNumberToRMB(String m) {
		String num = "��Ҽ��������½��ƾ�";
		String dw = "Բʰ��Ǫ����";
		String mm[] = null;
		mm = m.split(".");
		String money = mm[0];

		String result = num.charAt(Integer.parseInt("" + mm[1].charAt(0)))
		+ "��" + num.charAt(Integer.parseInt("" + mm[1].charAt(1)))
		+ "��";

		for (int i = 0; i < money.length(); i++) {
			String str = "";
			int n = Integer.parseInt(money.substring(money.length() - i - 1,
					money.length() - i));
			str = str + num.charAt(n);
			if (i == 0) {
				str = str + dw.charAt(i);
			} else if ((i + 4) % 8 == 0) {
				str = str + dw.charAt(4);
			} else if (i % 8 == 0) {
				str = str + dw.charAt(5);
			} else {
				str = str + dw.charAt(i % 4);
			}
			result = str + result;
		}
		result = result.replaceAll("��([^����Բ�Ƿ�])", "��");
		result = result.replaceAll("����+��", "����");
		result = result.replaceAll("��+", "��");
		result = result.replaceAll("��([����Բ])", "");
		result = result.replaceAll("Ҽʰ", "ʰ");

		return result;
	}

	/**
	 * ��ָ���ַ�תΪUTF-8����
	 */
	public static String toUtf8String(String s) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c >= 0 && c <= 255) {
				sb.append(c);
			} else {
				byte[] b;
				try {
					b = Character.toString(c).getBytes("utf-8");
				} catch (Exception ex) {
					ex.printStackTrace();
					b = new byte[0];
				}
				for (int j = 0; j < b.length; j++) {
					int k = b[j];
					if (k < 0)
						k += 256;
					sb.append("%" + Integer.toHexString(k).toUpperCase());
				}
			}
		}
		return sb.toString();
	}

	/**
	 * ȡ��ǰ���ڣ����ع̶���ʽ�ַ�
	 */
	public static String getNow() {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
	}

	/**
	 * ȡ��ǰ���ڣ�����Date��ʽ
	 */
	public static Date getNowDate() {
		return new Date();
	}

	/**
	 * ���ָ����ţ�����ַ� ������Ϊ�գ����ؿն��󣬽����쳣�췵�ؿն���
	 * 
	 * @param orgString
	 *            Դ�ַ�
	 * @param ָ�����
	 * @return ��ֺ������
	 */
	public static String[] getStringArray(String orgString, String flag) {
		String[] returnValue = null;
		try {
			if (orgString != null && flag != null && !"".equals(orgString)) {
				returnValue = orgString.split(flag);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return returnValue;
	}

	/**
	 * ���8λ���к�,����ǰ׺�ܹ�10λ,���㲹0
	 * 
	 * @author ����
	 * @param prefix
	 * @param seqNumber
	 *            ���к�
	 * @return
	 */
	public static String generateCode(String prefix, String seqNumber) {
		StringBuffer sb = new StringBuffer();
		sb.append(prefix);
		int len = seqNumber.length();
		int addZeorLen = 8 - len;
		if (addZeorLen < 0) {
			addZeorLen = 0;
		}

		for (int i = 0; i < addZeorLen; i++) {
			sb.append("0");
		}
		sb.append(seqNumber);
		return sb.toString();
	}

	/**
	 * ��ָ����ʽת���ַ�Ϊʱ���ʽ�����ת���쳣���򷵻ؿն���
	 * 
	 * @param sDate
	 *            ʱ���ַ��ʽ
	 * @param format
	 *            ��ʽformat
	 * @return
	 */
	public static Date StringToDate(String sDate, String format) {
		Date date = null;
		if (sDate != null && format != null && !"".equals(sDate)) {
			SimpleDateFormat df = new SimpleDateFormat(format);
			try {
				date = df.parse(sDate);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		return date;

	}

	/**
	 * ������ƣ�dateToString ����ժҪ����һ������ת�����ַ��磺2008-08-18
	 * 
	 * @param Date
	 *            date ��Ҫת��������
	 * @return String ����һ���ַ�����
	 */
	public static String dateToString(Date date) {
		if (date != null) {
			return dateFormat.format(date);
		} else {
			return "";
		}
	}

	/**
	 * ����:�Ѷ���������ֵΪ���Ӵ���תΪnull
	 * 
	 * @param obj
	 *            Ҫת���Ķ���
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static Object ConvertEmptyValueToNull(Object obj) {
		Class c = obj.getClass();
		try {
			Field[] fs = c.getDeclaredFields();
			for (int i = 0; i < fs.length; i++) {
				if (fs[i].getType().toString().equals(String.class.toString())) {
					String name = fs[i].getName();// �õ���ǰ���е��ֶ����,��Ϊֻ�й��еĲ��ܷ���
					String getname = "get"
						+ String.valueOf(name.charAt(0)).toUpperCase()
						+ name.substring(1);// ��ϳ�get����
					String setname = "set"
						+ String.valueOf(name.charAt(0)).toUpperCase()
						+ name.substring(1);// ��ϳ�set����
					Method getMethod = c.getDeclaredMethod(getname);// �õ����������ж���ķ���
					String str = (String) getMethod.invoke(obj);// ȡ�������еķ���ֵ��Ҳ����STRUTS��ǰ̨����η���BEAN�е�ֵ
					if (str != null && str.length() == 0) {
						Method setMethod = c.getDeclaredMethod(setname,
								String.class);// �õ�set������ʵ��
						setMethod.invoke(obj, new Object[] { null });// ����set������ֵΪnull
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return obj;
	}

	/**
	 * �ṩ��ȷ��С��λ�������봦�?
	 * 
	 * @param v
	 *            ��Ҫ�������������
	 * @param scale
	 *            С��������λ
	 * @return ���������Ľ��
	 */
	public static double round(double v, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException(
			"The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Double.toString(v));
		BigDecimal one = new BigDecimal("1");
		return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
	}


	public static String nullToString(Object obj) {
		return obj != null ? obj.toString() : "";
	}

	/**
	 * ����HIBERNATE�Ĳ�ѯ����,��������ѯ,������ͼ ��:select a.userName,b.sid,c.dd from InfoUser
	 * a,InfoDept b,sh c ���Ϊ:[userName,sid,dd]
	 * 
	 * @param sql
	 * @return
	 */
	public static String[] getMetaData(String sql) {
		String[] source = sql.split("(?i)from")[0].split("select")[1]
		                                                           .split(",");
		String[] dest = new String[source.length];
		for (int i = 0; i < source.length; i++) {
			String[] tmp = source[i].trim().split("\\.")[source[i].trim()
			                                             .split("\\.").length - 1].split(" ");
			dest[i] = tmp[tmp.length - 1];
		}
		return dest;
	}

	public static String encodeStrToUtf8(String orgStr) {
		String result = orgStr;
		try {
			result = new String(orgStr.getBytes("GB2312"), "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return result;
	}
}
